《Java语言程序设计》期末试卷A (精选01)

注意：所有答案均写在答卷上，写在试卷上无效。

（一）单选题（每题 2 分，共 26 分）

(1) 下列语句中，正确的是（）

A. float x = 0.0;
B. boolean b = 3 > 5;
C. char c = "A";
D. double π = 3.14;

查看答案与解析

答案：B

解析：

A 错误：0.0 默认是 double 类型，不能直接赋给 float 变量，应写为 0.0f。
B 正确：3 > 5 是一个布尔表达式，结果为 false，可以赋给 boolean 变量。
C 错误："A" 是字符串（String），不能赋给 char 变量，应使用单引号 'A'。
D 错误：虽然 Java 技术上支持 Unicode 字符作为标识符（π 是合法标识符），double π = 3.14; 语法上可以通过编译，但本题考查常规编程规范，且题目要求选出唯一正确答案。从实际编程规范角度，不推荐使用非 ASCII 字符作为标识符，因此 D 不作为最佳答案。

难度: ⭐ 考点: #数据类型 #float #boolean #char

💡 学习锦囊

📖 相关公式与知识点:

float 赋值：float x = 0.0f;，小数默认是 double，需加 f 后缀。
boolean 类型：只有 true 和 false，布尔表达式的结果可直接赋值。
char 类型：使用单引号 'A'，双引号 "A" 是 String 类型。

易错点

0.0 是 double 类型，不能直接赋给 float。

🔄 举一反三

下列哪个是合法的 float 类型赋值？
- A. float f = 1.0;
- B. float f = 1.0f;
- C. float f = (float)1.0d;
- D. B 和 C 都正确
查看练习答案与解析
答案：D 解析：A 中 1.0 是 double，不能直接赋给 float。B 使用 f 后缀正确。C 使用强制类型转换也正确。

(2) 设有定义：int k = 3; 值为 true 的表达式是（）

A. k = 3;
B. k++ == 3;
C. ++k == 3;
D. k++ == 3++

查看答案与解析

答案：B

解析：

A：k = 3 是赋值语句，不是比较表达式，结果为 3（int），不是 boolean。
B：k++ == 3，k 先取值 3 与 3 比较（true），然后 k 自增为 4。结果为 true。
C：++k == 3，k 先自增为 4，再与 3 比较，结果为 false。
D：3++ 是非法表达式，常量不能自增。

难度: ⭐ 考点: #自增运算 #比较运算符

💡 学习锦囊

📖 相关公式与知识点:

自增运算：k++（先用后加），++k（先加后用）。
赋值 vs 比较：= 是赋值，== 是比较。

易错点

k = 3 是赋值不是比较，k == 3 才是比较。
常量不能自增（如 3++ 非法）。

🔄 举一反三

设有 int a = 5;，执行 int b = a++; 后，a 和 b 的值分别是多少？
查看练习答案与解析
答案：a = 6, b = 5 解析：a++ 先用后加，b 取到 a 的当前值 5，然后 a 自增为 6。

(3) 能使程序块显示字符串"good"的 x 值的范围是（）

java

if (x > 0) System.out.println("excellent");
else if (x > -3) System.out.println("good");
else System.out.println("normal");

A. x > 0
B. x > -3
C. x <= -3
D. -3 < x <= 0

查看答案与解析

答案：D

解析： 程序逻辑分析：

当 x > 0 时，输出 "excellent"。
当 x <= 0 且 x > -3 时，即 -3 < x <= 0，输出 "good"。
当 x <= -3 时，输出 "normal"。

要输出 "good"，需要满足 -3 < x <= 0，故选 D。

难度: ⭐ 考点: #条件语句 #if-else

💡 学习锦囊

📖 相关公式与知识点:

if-else if-else 链：从上到下依次判断，第一个满足条件的分支执行后，后续分支不再判断。
区间表示：-3 < x <= 0 表示 x 在 (-3, 0] 区间内。

易错点

注意 else if 的条件是在前面条件不满足的前提下判断的。

🔄 举一反三

若 x = -5，上述程序输出什么？
查看练习答案与解析
答案：normal 解析：x = -5，不满足 x > 0，也不满足 x > -3，执行最后的 else 分支。

(4) 设有定义：int[] a = {4, 2, -7, 5, 1, 6, 3}; 则 a[a[4]] 的值为（）

A. 4
B. 2
C. -7
D. 5

查看答案与解析

答案：B

解析： 数组 a = {4, 2, -7, 5, 1, 6, 3}，索引从 0 开始：

a[4] = 1
a[a[4]] = a[1] = 2

对应选项 B（值为 2）。

难度: ⭐ 考点: #数组 #索引

💡 学习锦囊

📖 相关公式与知识点:

数组索引：从 0 开始，a[i] 表示第 i+1 个元素。
嵌套索引：a[a[i]] 先计算内层 a[i] 的值，再作为外层索引。

易错点

数组索引从 0 开始，a[4] 是第 5 个元素。

🔄 举一反三

设有 int[] arr = {10, 20, 30, 40, 50};，arr[arr[0]/10] 的值是多少？
查看练习答案与解析
答案：20 解析：arr[0] = 10，10/10 = 1，arr[1] = 20。

(5) 关于方法的返回值，以下说法正确的是（）

A. 方法必须有返回值
B. 方法可以没有返回值，也可以有多个返回值
C. 方法有且仅有一个返回值
D. 方法必须有至少一个返回值

查看答案与解析

答案：C

解析：

A 错误：方法可以没有返回值（void）。
B 错误：方法最多只能有一个返回值，不能有多个。
C 正确：方法要么没有返回值（void），要么有且仅有一个返回值。
D 错误：void 方法不需要返回值。

难度: ⭐ 考点: #方法 #返回值

💡 学习锦囊

📖 相关公式与知识点:

方法返回值：void 方法无返回值，非 void 方法必须有且仅有一个返回值（通过 return 语句）。
return 语句：结束方法执行并返回结果。

易错点

Java 方法不能返回多个值，如需返回多个值，可使用数组或对象封装。

🔄 举一反三

判断：void 方法中可以使用 return; 语句。（）
查看练习答案与解析
答案：√ 解析：void 方法中可以使用不带返回值的 return; 来提前结束方法。

(6) 设 Tree 为已定义的类名，下列语句能正确创建 Tree 对象的是（）

A. Tree t = new Tree;
B. Tree t = new Tree();
C. Tree t = Tree();
D. Tree t[] = new Tree[10];

查看答案与解析

答案：B

解析：

A 错误：缺少小括号 ()。
B 正确：new Tree() 是标准的对象创建语法。
C 错误：缺少 new 关键字。
D 错误：new Tree[10] 创建的是数组，不是单个对象。

难度: ⭐ 考点: #对象创建 #new关键字

💡 学习锦囊

📖 相关公式与知识点:

对象创建语法：类名变量名 = new 类名(参数);
new 关键字：在堆内存中分配空间，调用构造方法初始化对象。

易错点

new Tree[10] 创建的是数组（存放 10 个 Tree 引用的数组），不是 Tree 对象。

🔄 举一反三

判断：String s = new String("hello"); 和 String s = "hello"; 效果完全相同。（）
查看练习答案与解析
答案：× 解析：new String("hello") 在堆中创建新对象，"hello" 使用字符串常量池。两者内存位置不同。

(7) 在 Applet 的运行过程中，下列什么方法只能执行一次（）

A. init()
B. start()
C. stop()
D. paint()

查看答案与解析

答案：A

解析： Applet 生命周期：

init()：初始化，只执行一次。
start()：启动，每次访问页面时执行。
stop()：停止，每次离开页面时执行。
paint()：绘制，可多次调用。

难度: ⭐ 考点: #Applet #生命周期

💡 学习锦囊

📖 相关公式与知识点:

Applet 生命周期：init() → start() → paint() → stop() → destroy()。
init()：只执行一次，用于初始化。
paint()：每次重绘时调用，可多次执行。

易错点

init() 只执行一次，start() 和 paint() 可多次执行。

🔄 举一反三

判断：Applet 的 destroy() 方法在浏览器关闭时调用，只执行一次。（）
查看练习答案与解析
答案：√ 解析：destroy() 在 Applet 被销毁时调用，只执行一次，用于释放资源。

(8) 指出下列哪个方法与方法 public void change(int x, int y){} 为不合理的重载方法（）

A. public long change(long x, long y){}
B. public float change(float x, float y){}
C. public void change(int x){}
D. public int change(int a, int b){}

查看答案与解析

答案：D

解析： 方法重载（Overload）要求：方法名相同，参数列表不同（参数个数或类型不同）。

A：参数类型为 (long, long)，与原方法 (int, int) 不同，是合法重载。
B：参数类型为 (float, float)，合法重载。
C：参数个数为 1 个，合法重载。
D：参数类型为 (int, int)，与原方法完全相同，仅返回类型不同不构成重载，编译报错。

难度: ⭐ 考点: #方法重载

💡 学习锦囊

📖 相关公式与知识点:

方法重载：方法名相同，参数列表不同（类型、个数、顺序），与返回类型无关。
重载判断：只看方法名和参数列表，不看返回类型。

易错点

方法重载只看参数列表，返回类型不同不算重载。

🔄 举一反三

判断：void f(int a) 和 int f(int a) 构成方法重载。（）
查看练习答案与解析
答案：× 解析：参数列表完全相同，仅返回类型不同，不构成重载，编译报错。

(9) 为了以字符方式从文件读出内容，可以使用（）类

A. FileReader
B. FileInputStream
C. FileOutputStream
D. FileWriter

查看答案与解析

答案：A

解析：

FileReader：字符输入流，以字符方式读取文件。✓
FileInputStream：字节输入流，以字节方式读取。
FileOutputStream：字节输出流。
FileWriter：字符输出流。

难度: ⭐ 考点: #文件IO #字符流 #字节流

💡 学习锦囊

📖 相关公式与知识点:

字符流 vs 字节流：Reader/Writer 是字符流，InputStream/OutputStream 是字节流。
FileReader：字符输入流，用于读取文本文件。
FileWriter：字符输出流，用于写入文本文件。

易错点

读取用 Reader/InputStream，写入用 Writer/OutputStream。

🔄 举一反三

以字节方式写入文件应使用哪个类？
查看练习答案与解析
答案：FileOutputStream 解析：FileOutputStream 是字节输出流，用于以字节方式写入文件。

(10) 以下关于构造方法的描述错误的是（）

A. 构造方法的返回类型只能是 void 型
B. 构造方法是类的一种特殊方法，它的方法名必须与类名相同
C. 构造方法的主要作用是完成对类的对象的初始化工作
D. 一个类可以定义多个构造方法

查看答案与解析

答案：A

解析： 构造方法没有返回类型，连 void 也不能写。如果写了 void，它就变成了普通方法，不再是构造方法。因此 A 的描述是错误的。

难度: ⭐ 考点: #构造方法

💡 学习锦囊

📖 相关公式与知识点:

构造方法：无返回类型，与类同名，用于初始化对象。
构造方法重载：一个类可以定义多个参数列表不同的构造方法。

易错点

构造方法没有返回类型，void 也不能写。

🔄 举一反三

判断：如果一个类没有定义任何构造方法，编译器会自动生成一个无参构造方法。（）
查看练习答案与解析
答案：√ 解析：如果类中没有定义任何构造方法，编译器会自动添加默认的无参构造方法。

(11) 数学表达式 $$|x| < 10$$ 对应的 Java 表达式为（）

A. |x| < 10
B. x < 10 && x > -10
C. x < 10 || x > -10
D. 10 > x > -10

查看答案与解析

答案：B

解析： $$|x| < 10$$ 等价于 $$-10 < x < 10$$ ，即 $$x > -10$$ 且 $$x < 10$$ 。

A：Java 中没有 || 绝对值运算符。
B：x < 10 && x > -10，正确。
C：|| 是或，逻辑错误。
D：Java 不支持连续比较。

难度: ⭐ 考点: #逻辑运算符 #绝对值

💡 学习锦囊

📖 相关公式与知识点:

绝对值不等式： $$|x| < a$$ 等价于 $$-a < x < a$$ 。
逻辑运算符：&&（与）、||（或）、!（非）。
Java 不支持连续比较：a < b < c 在 Java 中非法。

易错点

Java 中没有 || 绝对值运算符，需用 Math.abs() 或逻辑表达式。

🔄 举一反三

$|x| \geq 5$ 对应的 Java 表达式是什么？
查看练习答案与解析
答案：x >= 5 || x <= -5 或 Math.abs(x) >= 5解析： $|x| \geq 5$ 等价于 $x \geq 5$ 或 $x \leq -5$ 。

(12) 设有整型变量 a, b, c，其中 a, b 的值分别为 10 与 20，在执行语句 c = (a < b) ? a : b; 后，c 的值为（）

A. 0
B. 1
C. 10
D. 20

查看答案与解析

答案：C

解析： 三元运算符 (条件) ? 值1 : 值2：

a < b 即 10 < 20 为 true。
返回 a，即 10。
所以 c = 10。

难度: ⭐ 考点: #三元运算符

💡 学习锦囊

📖 相关公式与知识点:

三元运算符：条件 ? 表达式1 : 表达式2，条件为 true 返回表达式1，否则返回表达式2。
等价于：if (条件) 变量 = 表达式1; else 变量 = 表达式2;

易错点

三元运算符的返回值类型由表达式1和表达式2的类型共同决定。

🔄 举一反三

int max = (a > b) ? a : b; 的功能是什么？
查看练习答案与解析
答案：求 a 和 b 中的最大值并赋给 max。解析：如果 a > b，返回 a；否则返回 b。

(13) （）定义了一个合法的抽象类

A. abstract Shape {abstract void area();}
B. class abstract Shape {abstract void area();}
C. abstract class Shape {abstract void area();}
D. abstract class Shape {abstract void area() {System.out.println("area");}}

查看答案与解析

答案：C

解析：

A 错误：缺少 class 关键字。
B 错误：class abstract 顺序错误，应为 abstract class。
C 正确：abstract class Shape {abstract void area();} 语法完全正确。
D 错误：抽象方法不能有方法体（大括号内的实现）。

难度: ⭐ 考点: #抽象类 #抽象方法

💡 学习锦囊

📖 相关公式与知识点:

抽象类：abstract class 定义，不能被实例化。
抽象方法：abstract 修饰，无方法体（没有 {}），以分号结尾。
语法顺序：abstract class 类名，不是 class abstract 类名。

易错点

抽象方法不能有方法体。
抽象类中可以包含非抽象方法。

🔄 举一反三

判断：抽象类中可以包含非抽象方法。（）
查看练习答案与解析
答案：√ 解析：抽象类中可以同时包含抽象方法（无方法体）和非抽象方法（有方法体）。但含有抽象方法的类必须声明为抽象类。

（二）程序阅读（每题 4 分，共 24 分）

(1) 以下程序的输出结果为______

java

public class Test {
    public static void main(String[] args) {
        int a = 18, b = 5, c = 6;
        int m = 0;
        if (a > b)
            if (a > c) m = a;
            else m = c;
        else
            if (b > c) m = b;
            else m = c;
        System.out.println(m);
    }
}

查看答案与解析

答案：18

解析： 程序求 a, b, c 中的最大值：

a = 18, b = 5, c = 6
a > b（18 > 5）为 true → 进入第一个 if 分支
a > c（18 > 6）为 true → m = a = 18
输出 18

注意 else 与最近的 if 配对（悬空 else 问题）。此处 else m = c 与 if (a > c) 配对。

难度: ⭐⭐ 考点: #if-else #悬空else

💡 学习锦囊

📖 相关公式与知识点:

悬空 else：else 与最近的未配对 if 配对，注意缩进可能具有误导性。
嵌套 if-else：使用大括号 {} 可以明确配对关系，避免歧义。

易错点

else 总是与最近的 if 配对，不要被缩进误导。

🔄 举一反三

以下程序输出什么？
java
```
int x = 10, y = 5;
if (x > 5)
    if (y > 5) System.out.println("A");
    else System.out.println("B");
```
1
2
3
4
查看练习答案与解析
答案：B 解析：x > 5 为 true，进入内层 if。y > 5 为 false，执行 else 输出 B。else 与 if (y > 5) 配对。

(2) 以下程序，若运行时输入 1 3 -5 -7 9，输出结果为______

java

import java.util.*;
class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x, s = 0;
        for (int i = 0; i < 5; i++) {
            x = sc.nextInt();
            if (x > 0) s += x;
            else break;
        }
        System.out.println(s);
    }
}

查看答案与解析

答案：4

解析： 程序逐个读取输入的整数，若为正数则累加，遇到非正数则 break 退出循环。

输入序列：1, 3, -5, -7, 9

i=0：x=1 > 0，s = 0+1 = 1
i=1：x=3 > 0，s = 1+3 = 4
i=2：x=-5 ≤ 0，break 退出

输出 s = 4

难度: ⭐⭐ 考点: #Scanner #break #循环

💡 学习锦囊

📖 相关公式与知识点:

Scanner：Scanner sc = new Scanner(System.in); 用于读取控制台输入。
break：跳出当前循环，不再执行后续迭代。
nextInt()：读取下一个整数。

易错点

break 后循环直接结束，后续输入不再处理。

🔄 举一反三

若输入 2 4 6 8 10，上述程序输出什么？
查看练习答案与解析
答案：30 解析：所有数都为正数，全部累加：2+4+6+8+10 = 30。

(3) 以下程序的输出结果为______

java

class A {
    public static void main(String[] args) {
        int y = 4;
        A a = new A();
        a.f(y);
        System.out.println("y is " + y);
    }
    public void f(int x) {
        x++;
    }
}

查看答案与解析

答案：y is 4

解析： Java 中基本类型参数是值传递。方法 f(int x) 接收的是 y 的副本，x 自增不影响原变量 y。所以 y 仍为 4。

难度: ⭐⭐ 考点: #值传递

💡 学习锦囊

📖 相关公式与知识点:

值传递：Java 基本类型参数传递的是值的副本，方法内修改不影响实参。
引用传递：数组、对象等引用类型传递的是引用（地址），方法内通过引用修改会影响原对象。

易错点

值传递中方法内修改不影响原始变量。

🔄 举一反三

以下程序输出什么？
java
```
int[] arr = {1, 2, 3};
void modify(int[] a) { a[0] = 99; }
// 调用 modify(arr) 后输出 arr[0]
```
1
2
3
查看练习答案与解析
答案：99 解析：数组是引用类型，传递的是引用（地址），方法内通过引用修改数组元素会影响原数组。这与基本类型的值传递不同。

(4) 以下程序的输出结果为______

java

class Word {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = s1.toUpperCase();
        System.out.print(s1);
        System.out.print(s2);
    }
}

查看答案与解析

答案：HelloHELLO

解析：

s1 = "Hello"，s1.toUpperCase() 返回新字符串 "HELLO"，不改变 s1。
s1 仍为 "Hello"，s2 为 "HELLO"。
输出 HelloHELLO。

难度: ⭐⭐ 考点: #String不可变

💡 学习锦囊

📖 相关公式与知识点:

String 不可变：toUpperCase(), substring() 等方法返回新字符串，不修改原字符串。
String 常用方法：toUpperCase(), toLowerCase(), trim(), substring(), replace() 等都返回新字符串。

易错点

String 的方法不会修改原字符串，总是返回新字符串。

🔄 举一反三

以下程序输出什么？
java
```
String s = "abc";
s.toUpperCase();
s.replace('a', 'A');
System.out.println(s);
```
1
2
3
4
查看练习答案与解析
答案：abc 解析：String 是不可变类，toUpperCase() 和 replace() 都返回新字符串，原字符串 s 不受影响。需要写成 s = s.toUpperCase() 才能改变 s 的引用。

(5) 以下程序的输出结果为______

java

class Test {
    public static void main(String[] args) {
        int i;
        int a[] = {2, 6, 1, 8, 7, 4, 5};
        int max = a[0];
        for (i = 0; i < a.length; i++)
            if (max > a[i]) max = a[i];
        System.out.print(max);
    }
}

查看答案与解析

答案：1

解析： 注意程序变量名为 max，但比较条件是 max > a[i]（找比 max 小的元素），实际上是在找最小值。

初始 max = a[0] = 2
i=0: 2 > 2 false
i=1: 2 > 6 false
i=2: 2 > 1 true → max = 1
i=3: 1 > 8 false
i=4: 1 > 7 false
i=5: 1 > 4 false
i=6: 1 > 5 false

输出 1。变量名 max 具有误导性，实际功能是求最小值。

难度: ⭐⭐ 考点: #数组遍历 #变量名误导

💡 学习锦囊

📖 相关公式与知识点:

数组遍历：使用 for 循环遍历数组元素。
求最大值：if (max < a[i]) max = a[i];
求最小值：if (min > a[i]) min = a[i];

易错点

变量名与功能不符时容易误判，要仔细看比较符号。

🔄 举一反三

将上述程序中的 if (max > a[i]) 改为 if (max < a[i])，输出什么？
查看练习答案与解析
答案：8 解析：改为 < 后，程序真正求最大值，数组最大值为 8。

(6) 当下面代码编译时，第______行有语法错误

java

#1 class Person {
#2     private String name;
#3 }
#4 public class Student extends Person {
#5     private String department;
#6     public String getValue() { return name; }
#7     public static void main(String arg[]) {
#8         Person p = new Person();
#9     }
#10 }

查看答案与解析

答案：第 6 行

解析： 第 6 行：public String getValue() { return name; }

name 在 Person 类中声明为 private，private 成员只能在自身类中访问，子类 Student 无法直接访问父类的 private 成员。编译报错。

难度: ⭐⭐ 考点: #访问控制 #private #继承

💡 学习锦囊

📖 相关公式与知识点:

访问控制：private → 只能在本类中访问；protected → 本包 + 其他包子类；default → 本包；public → 任意位置。
继承与访问权限：子类不能直接访问父类的 private 成员，但可以通过父类提供的 public/protected 方法间接访问。

易错点

private 成员子类不可访问。

🔄 举一反三

如果 Person 类中 name 声明为 protected，第 6 行是否还有错误？
查看练习答案与解析
答案：没有错误解析：protected 成员可以被子类（即使在不同包中）直接访问。

（三）程序填空题（每空 2 分，共 18 分）

(1) 以下程序将 200 以内的质数以字符方式写入文件 jd.dat

java

import java.io.*;
public class test {
    public static void main(String args[]) {
        try {
            FileWriter out = new ______(1)______("jd.dat");
            int k;
            for (int i = 2; i < 200; i++) {
                for (k = 2; k < i; k++)
                    if (i % k == 0) ______(2)______;
                if (k >= i) out.write(i + "");
            }
            ______(3)______;
        } catch (IOException e) {}
    }
}

查看答案与解析

答案：

(1) FileWriter
(2) break
(3) out.close()

解析：

(1) new FileWriter("jd.dat") 创建文件字符输出流，与前面的 FileWriter out 类型一致。
(2) 内层循环检测 i 是否能被 k 整除，若能则 i 不是质数，用 break 跳出内层循环。
(3) 写入完成后必须关闭流 out.close()，释放资源。

难度: ⭐⭐ 考点: #文件IO #FileWriter #质数判断

💡 学习锦囊

📖 相关公式与知识点:

FileWriter：字符输出流，用于以字符方式写入文件。常用方法：write(), close(), flush()。
质数判断：若 n 不能被 2 到 n-1 之间的任何整数整除，则 n 为质数。

易错点

文件操作后必须关闭流，否则数据可能丢失。
质数判断中 break 后 k 的值小于 i，利用这个特性判断是否为质数。

🔄 举一反三

使用 BufferedReader 读取文件内容并逐行输出，补全代码：
java
```
BufferedReader br = new BufferedReader(new ______("test.txt"));
String line;
while ((line = br.______) != null) {
    System.out.println(line);
}
```
1
2
3
4
5
查看练习答案与解析
答案：FileReader，readLine()解析：BufferedReader 需要一个 Reader 对象作为参数，FileReader 是最常用的字符输入流。readLine() 逐行读取，返回 null 表示文件结束。

(2) 编写类 Point，用以表示直角坐标系中的点。其中 distance() 方法返回当前点到坐标原点的距离

java

public class Point {
    private double x, y;
    Point(double a, double b) {
        ______(4)______;
        y = b;
    }
    double distance() {
        ______(5)______;
    }
    public static void main(String args[]) {
        Point p1 = new Point(3, 4);
        System.out.print(______(6)______);
    }
}

查看答案与解析

答案：

(4) x = a
(5) return Math.sqrt(x * x + y * y)
(6) p1.distance()

解析：

(4) 构造方法中为成员变量 x 赋值，x = a。
(5) 点 $$(x, y)$$ 到原点的距离公式： $d = \sqrt{x^2 + y^2}$ ，使用 Math.sqrt() 计算。
(6) 调用 p1 的 distance 方法输出距离。

难度: ⭐⭐ 考点: #构造方法 #Math.sqrt #距离公式

💡 学习锦囊

📖 相关公式与知识点:

点到原点距离： $d = \sqrt{x^2 + y^2}$ ，使用 Math.sqrt() 计算。
构造方法赋值：this.x = a; 或 x = a;（当参数名与成员变量名不同时）。

易错点

Math.sqrt() 返回 double 类型。

🔄 举一反三

计算 Point(6, 8) 到原点的距离。
查看练习答案与解析
答案：10.0 解析： $d = \sqrt{6^2 + 8^2} = \sqrt{36 + 64} = \sqrt{100} = 10.0$ 。这是一个经典的勾股数（3-4-5 的倍数）。

(3) 以下 Java 小程序运行时显示窗口，在文本框内输入"Bob"后点击按钮，则在后面的文本框内输出"Bob,Welcome!"

java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class test ______(7)______ JFrame implements ActionListener {
    TextField input, output;
    public test() {
        Label prompt = new Label("Input", true);
        Button btn = new Button("ok");
        output = new TextField(20);
        input = new TextField(6);
        output.setEditable(false);
        ______(8)______;
        add(input);
        add(btn);
        add(output);
        ______(9)______;
    }
    public void actionPerformed(ActionEvent e) {
        output.setText(input.getText() + ",Welcome!");
    }
    public static void main(String[] args) {
        test t = new test();
        t.setSize(300, 100);
        t.setVisible(true);
    }
}

查看答案与解析

答案：

(7) extends
(8) setLayout(new FlowLayout())（或其他布局设置）
(9) btn.addActionListener(this)

解析：

(7) 类 test 继承 JFrame，使用 extends 关键字。
(8) 设置布局管理器，JFrame 默认是 BorderLayout，需要改为 FlowLayout 以便组件水平排列。
(9) 为按钮注册事件监听器，btn.addActionListener(this) 使当前对象处理按钮点击事件。

注意：原程序使用 init() 方法（Applet 风格）但继承的是 JFrame，已修正为构造方法，并补充了 main 方法和 javax.swing.* 导入。

难度: ⭐⭐ 考点: #JFrame #ActionListener #布局管理器

💡 学习锦囊

📖 相关公式与知识点:

GUI 事件处理：事件源（Button）→ 注册监听器（addActionListener）→ 事件处理（actionPerformed）。
FlowLayout：流式布局，组件从左到右排列，排满换行。
extends：继承关键字。

易错点

GUI 中忘记注册事件监听器，按钮点击无响应。

🔄 举一反三

在 Swing 中，如何为按钮添加点击事件？
查看练习答案与解析
答案：button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { /* 处理代码 */ } });解析：可以通过匿名内部类或让当前类实现 ActionListener 接口来注册事件监听器。

（三）程序设计题（第 1、2 题各 10 分，第 3 题 12 分，共 32 分）

(1) 编写程序，计算并输出以下表达式的值。

s = 1 + \frac{1}{3} + \frac{1}{5} + \frac{1}{7} + \dots + \frac{1}{99}

查看答案与解析

答案：

java

public class SeriesSum {
    public static void main(String[] args) {
        double s = 0;
        for (int i = 1; i <= 99; i += 2) {
            s += 1.0 / i;
        }
        System.out.println("s = " + s);
    }
}

解析：

第一步：分析数列规律 分母为 1, 3, 5, 7, ..., 99，即从 1 开始的奇数，步长为 2。

第二步：确定循环结构 使用 for 循环，i 从 1 开始，每次加 2，直到 99。

第三步：注意整数除法陷阱1 / i 中如果 i 是 int，则执行整数除法。必须使用 1.0 / i 确保浮点除法。

难度: ⭐⭐ 考点: #循环 #数列求和 #整数除法

💡 学习锦囊

📖 相关公式与知识点:

奇数序列：for (int i = 1; i <= n; i += 2)
整数除法 vs 浮点除法：1 / 3 = 0（整数除法），1.0 / 3 = 0.333...（浮点除法）。

易错点

整数除法会截断小数部分，必须用 1.0 / i 确保浮点运算。

🔄 举一反三

计算 $s = 1 - \frac{1}{2} + \frac{1}{3} - \frac{1}{4} + \dots + \frac{1}{99} - \frac{1}{100}$
查看练习答案与解析
java
```
double s = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 1) s += 1.0 / i;
    else s -= 1.0 / i;
}
```
1
2
3
4
5
解析：奇数项加，偶数项减，使用 i % 2 判断奇偶。

(2) 输入 50 个学生的某门课的成绩，输出高于平均分的学生人数。

查看答案与解析

答案：

java

import java.util.Scanner;

public class ScoreAnalysis {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double[] scores = new double[50];
        double sum = 0;

        for (int i = 0; i < 50; i++) {
            scores[i] = sc.nextDouble();
            sum += scores[i];
        }

        double avg = sum / 50;
        int count = 0;
        for (int i = 0; i < 50; i++) {
            if (scores[i] > avg) {
                count++;
            }
        }

        System.out.println("高于平均分的学生人数：" + count);
    }
}

解析：

第一步：输入成绩并求和 使用循环读取 50 个成绩存入数组，同时累加求和。

第二步：计算平均分avg = sum / 50

第三步：统计高于平均分的人数 再次遍历数组，比较每个成绩与平均分，计数。

难度: ⭐⭐ 考点: #数组 #循环 #平均值

💡 学习锦囊

📖 相关公式与知识点:

平均值： $\bar{x} = \frac{\sum x_i}{n}$
两遍扫描：第一遍求和求平均，第二遍统计。

易错点

需要先求出平均分，再统计高于平均分的人数，不能边输入边统计。

🔄 举一反三

如何修改程序，同时输出最高分和最低分？

查看练习答案与解析

java

double max = scores[0], min = scores[0];
for (int i = 1; i < 50; i++) {
    if (scores[i] > max) max = scores[i];
    if (scores[i] < min) min = scores[i];
}

解析：在输入循环中同时维护 max 和 min 变量。

(3) 定义一个 Time 类，包含 hour 和 minute 两个私有成员变量，构造方法 Time(int hr, int mt)，方法 add(int m) 将时间增加 m 分钟（注意进位），方法 show() 输出时间。在 main 中创建 Time(23, 50)，调用 add(100) 后输出结果。

查看答案与解析

答案：

java

public class Time {
    private int hour;
    private int minute;

    public Time(int hr, int mt) {
        hour = hr;
        minute = mt;
    }

    public void add(int m) {
        int totalMinutes = hour * 60 + minute + m;
        hour = (totalMinutes / 60) % 24;
        minute = totalMinutes % 60;
    }

    public void show() {
        System.out.printf("%02d:%02d\n", hour, minute);
    }

    public static void main(String[] args) {
        Time t = new Time(23, 50);
        t.add(100);
        t.show();
    }
}

输出结果： 01:30

解析：

第一步：理解 add 方法的逻辑 将当前时间转换为总分钟数：totalMinutes = hour * 60 + minute + m

23:50 = 23 × 60 + 50 = 1430 分钟
加 100 分钟 = 1530 分钟

第二步：计算新的小时和分钟

新小时：(1530 / 60) % 24 = 25 % 24 = 1
新分钟：1530 % 60 = 30

第三步：验证结果 23:50 + 100 分钟 = 23:50 + 1小时40分钟 = 次日 01:30

难度: ⭐⭐ 考点: #类与对象 #时间计算 #取模运算

💡 学习锦囊

📖 相关公式与知识点:

时间换算：总分钟数 = 小时 × 60 + 分钟。
取模运算：% 24 确保小时在 0~23 范围内，% 60 确保分钟在 0~59 范围内。
格式化输出：System.out.printf("%02d:%02d", hour, minute) 补零显示。

易错点

小时进位后需要对 24 取模，否则可能超过 23。
分钟进位后需要对 60 取模。

🔄 举一反三

如果 Time(23, 50).add(70)，输出什么？
查看练习答案与解析
答案：01:00 解析：23:50 + 70 分钟 = 23:50 + 1小时10分钟 = 次日 01:00。

《Java语言程序设计》期末试卷A (精选01) ​

（一）单选题（每题 2 分，共 26 分） ​

（二）程序阅读（每题 4 分，共 24 分） ​

（三）程序填空题（每空 2 分，共 18 分） ​

（三）程序设计题（第 1、2 题各 10 分，第 3 题 12 分，共 32 分） ​

《Java语言程序设计》期末试卷A (精选01)

（一）单选题（每题 2 分，共 26 分）

（二）程序阅读（每题 4 分，共 24 分）

（三）程序填空题（每空 2 分，共 18 分）

（三）程序设计题（第 1、2 题各 10 分，第 3 题 12 分，共 32 分）